home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / Z80 emulator / PPC version / z80.reference.h < prev   
Encoding:
C/C++ Source or Header  |  1995-04-13  |  5.0 KB  |  149 lines  |  [TEXT/CWIE]
  1. /*    Z80 Emulator: header file
  2.     Copyright (C) 1995 G.Woigk
  3.     
  4.     This file is part of Mac Spectacle and it is free software
  5.     See application.c for details
  6.             
  7.     This program is distributed in the hope that it will be useful,
  8.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  9.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
  10. */
  11.  
  12. /*     override normal references to use separate variables and procedures for reference engine
  13.     all references in PPC Z80 engine to zreg, CORE, etc. now go to ref_zreg, REF_CORE, etc. instead!
  14.     caveat: #undef zreg, CORE, etc. after #including this file somewhere else !!!
  15. */
  16. #define    zreg                ref_zreg            // 2nd register set for Z80_Ref()
  17. #define    CORE                REF_CORE            // 2nd core for Z80_Ref()
  18. #define    Do_Output(A,B)        No_Output(A,B)     // ignore out's of Z80_Ref()
  19. #define    Do_Input(A)        Do_Input(A)        // hint: don't poll events between input of Z80_T() and Z80_Ref()
  20. #define    write_to_rom(A,B)    Dont_Write(A,B)    // don't write to ROM; Z80_T() shouldn't write to ROM too
  21.  
  22.  
  23. // -----    The Z80 RAM --------------------------------------------------------------
  24.  
  25. extern    Char        *CORE;            // RAM & ROM of Z80
  26.  
  27.  
  28. // -----    Flag tables ----------------------------------------------------------------
  29.  
  30. extern    Char        zlog_flags[256];    // convert:   A register  ->  z80 flags with V=parity and C=0
  31. extern    Char        mlog_flags[256];    // convert:   A register  ->  m68 flags with V=parity and C=0
  32. extern    Char        z80flags[256];        // convert:   m68 flag byte  ->  Z80 flag byte
  33. extern    Char        m68flags[256];    // convert:   Z80 flag byte  ->  m68 flag byte
  34.  
  35.  
  36. // -----    Z80 registers on entry and return of Z80() -----------------------------------
  37.  
  38. #define pair union _pair
  39. pair        {    Char        *ptr;
  40.             struct    {    Short corebase; Short reg; }    rr;
  41.             struct    {    Short corebase; Char hi,lo; }    r;
  42.         };
  43.  
  44. #define regs struct _regs        
  45. regs        {    pair        BC,DE,HL,IX,IY,IP,RP;
  46.             Short    BC2,DE2,HL2;
  47.             Char        AA2,A2,aa,A;    // A2 & A occupy ONE long register inside Z80()
  48.             Char        FF2, F2, ff, F;    // F2  & F occupy ONE long register inside Z80()
  49.             Char        I,            // hi byte of irpt vector
  50.                     irptcmd;        // lo byte of irpt vector read from data bus: 0xff            
  51.             Char        IFF1,IFF2;        
  52.             Char        EXIT,WUFF;    // watchdog flag & nmi/irpt flags
  53.             Char        R;            // 7 bit DRAM refresh counter
  54.             Char        IM;            // interrupt mode: 0 ... 2
  55.             long        CYCLES;        // processor T states (count down for interrupt)
  56.             long        TOTAL;        // T states since start of Z80 (overflows approx. every 20')
  57.         };
  58.  
  59. extern    regs        zreg;            // all z80 registers and flip flops are stored in this struct
  60.  
  61. // -----    definitions to ease the use of the z80 registers
  62.  
  63. #define    ra        zreg.A            // Z80() uses register variable 'a'
  64. #define    rf        zreg.F            // Z80() uses register variable 'f'
  65. #define    ra2        zreg.A2
  66. #define    rf2        zreg.F2
  67.  
  68. #define    abc        zreg.BC.ptr
  69. #define    bc        zreg.BC.rr.reg
  70. #define    rb        zreg.BC.r.hi
  71. #define    rc        zreg.BC.r.lo
  72.  
  73. #define    ade        zreg.DE.ptr
  74. #define    de        zreg.DE.rr.reg
  75. #define    rd        zreg.DE.r.hi
  76. #define    re        zreg.DE.r.lo
  77.  
  78. #define    ahl        zreg.HL.ptr
  79. #define    hl        zreg.HL.rr.reg
  80. #define    rh        zreg.HL.r.hi
  81. #define    rl        zreg.HL.r.lo
  82.  
  83. #define    aix        zreg.IX.ptr
  84. #define    ix        zreg.IX.rr.reg
  85. #define    xh        zreg.IX.r.hi
  86. #define    xl        zreg.IX.r.lo
  87.  
  88. #define    aiy        zreg.IY.ptr
  89. #define    iy        zreg.IY.rr.reg
  90. #define    yh        zreg.IY.r.hi
  91. #define    yl        zreg.IY.r.lo
  92.  
  93. #define    apc        zreg.IP.ptr    
  94. #define    pc        zreg.IP.rr.reg
  95. #define    pch        zreg.IP.r.hi
  96. #define    pcl        zreg.IP.r.lo
  97.  
  98. #define    asp        zreg.RP.ptr
  99. #define    sp        zreg.RP.rr.reg
  100. #define    sph        zreg.RP.r.hi
  101. #define    spl        zreg.RP.r.lo
  102.  
  103. #define    bc2        zreg.BC2
  104. #define    de2        zreg.DE2
  105. #define    hl2        zreg.HL2
  106.  
  107. #define    irpt_cmd    zreg.irptcmd        // read this interrupt vector / 1-byte instruction from bus
  108.  
  109. #define    disabled        0x00        // irpt flags
  110. #define    enabled        0xFF            // irpt flags
  111.  
  112. // bits in zreg.WUFF:
  113. #define    is_nmi        0x80        // non maskable interrupt: handled inside Z80()
  114. #define    is_irpt        0x7F            // normal interrupt counter: handled inside Z80()
  115.  
  116. // -----    Return values of Z80() -----------------------------------------------------
  117.  
  118. #define    watchdog_irpt    0            // watchdog exception (used for screen update & Mac OS event polling)
  119. #define    illegal_instr    1            // a not implemented instruction has been executed
  120. #define    halt_instr        2            // halt instruction executed
  121. #define    rst0_instr    3            // rst0 instruction executed
  122. #define    irpt_error    4            // not supported interrupt mode/instruction
  123.  
  124. // -----    Procedures -------------------------------------------------------------------
  125.  
  126. short    Z80_Ref ( );            
  127. short    CB_Instruction();
  128. short    ED_Instruction();
  129.  
  130. // -----    The following procedures must be supplied by the application program ---------------
  131.  
  132. extern    Do_Output        ( Short addr, Char n );    // Output byte to port
  133. Char        Do_Input         ( Short addr );            // Input byte from port
  134. extern    write_to_rom    ( Short A, Char N);        // Write byte to ROM (or don't)
  135.  
  136. #define    cc        zreg.CYCLES
  137. #define    store_cc
  138. #define    load_cc
  139.  
  140. #define    time(N)    cc-=N-4                        // T cycles for instruction
  141. #define    more(N)    cc-=N                        // adjust T cycles after use of time()
  142.  
  143. #define    exit(n)    return(n)
  144.  
  145. #define            wl    (Char)w                // access low byte of w
  146. #define            wh    (w>>8)                // access high byte of w
  147. #define            wml    (Char)wm                // access low byte of wm
  148. #define            wmh    (wm>>8)                // access high byte of wm
  149.